In pandas, you can use map(), apply(), and applymap() methods to apply functions to values (element-wise), rows, or columns in DataFrames and Series.

As mentioned later, DataFrame and Series already include methods for common operations. Additionally, you can apply NumPy functions to DataFrame and Series. Using dedicated methods or NumPy functions is preferable to map() or apply() due to better performance.

The pandas and NumPy versions used in this article are as follows. Note that functionality may vary between versions.

To apply a function to each value in a Series (element-wise), use the map() or apply() methods.

Passing a function to map() returns a new Series, with the function applied to each value. For example, apply the built-in hex() function to convert integers to hexadecimal strings.

You can also apply functions defined with def or lambda expressions.

The above example is for illustrative purposes; simple arithmetic operations can be directly performed on a Series.

By default, missing values (NaN) are passed to the function, but if you set the second argument na_action to 'ignore', NaN will not be passed to the function and the result will remain as NaN.

Because the presence of NaN changes the data type (dtype) to a floating-point number (float), values are converted to integers (int) using int() before being passed to hex() in the following example.

You can also pass a dictionary (dict) to map(). In this case, it replaces values. For more details, refer to the following article.

Similar to map(), the function specified as the first argument in apply() is applied to each value. The difference is that apply() allows you to specify arguments to be passed to the function.

With map(), you need to use a lambda expression or similar approach to pass arguments to the function. For example, specify the base argument in the int() function, which converts strings to integers.

With apply(), any specified keyword arguments are passed directly to the function. It is also possible to specify positional arguments using the args argument.

Note that even if there is only one positional argument, it must be specified as a tuple or list in the args argument. A comma is necessary at the end of a one-element tuple.

As of version 2.1.2, apply() does not have the na_action argument.

To apply a function to each value in a DataFrame (element-wise), use the map() or applymap() methods.

As of version 2.1.0, applymap() has been renamed to map() and marked as deprecated.

As of version 2.1.2, applymap() is still usable but issues a FutureWarning.

The following example uses map(), but applymap() has the same usage and functionality. In versions before 2.1.0, use applymap().

As with map() of Series, the na_action argument can be specified for map() of DataFrame. By default, missing values (NaN) are passed to the function, but if na_action is set to 'ignore', NaN is not passed to the function and the result remains as NaN.

Unlike map() of Series, map() of DataFrame passes the specified keyword argument to the function.

As of version 2.1.2, map() of DataFrame does not have the args argument, which means you cannot specify positional arguments.

To apply a function to rows or columns in a DataFrame, use the apply() method.

For the agg() method applying multiple operations at once, see the following article.

Specify the function you want to apply as the first argument.

Note that the built-in sum() function is used for explanation purposes, but if you need to calculate a sum, it is better to use the sum() method mentioned later.

By default, each column is passed to the function as a Series. If the function cannot accept a Series as an argument, an error will occur.

By default, the function is applied to each column. However, setting the axis argument to 1 or 'columns' applies it to each row.

Any keyword arguments specified in apply() are passed to the function being applied. You can also specify positional arguments using the args argument.

By default, each row or column is passed as a Series. If you set the raw argument to True, they are passed as NumPy arrays (ndarray).

If there's no need for a Series, using raw=True is faster since the conversion process is omitted. However, if the function requires Series methods or attributes, setting raw=True will raise an error.

To apply a function to a specific row or column, extract the row or column as a Series and use the map() or apply() methods of Series.

You can add them as new rows or columns. If the same row or column names are specified, they will be overwritten.

In pandas, common operations are provided as methods for DataFrame and Series, so there's no need to use map() or apply().

For a list of available methods, refer to the official documentation.

You can also process DataFrame and Series directly using arithmetic operators.

Methods for string manipulation are also available through the str accessor of Series.

You can process DataFrame and Series by passing them to NumPy functions.

For example, although pandas does not provide a method for truncating decimals, you can use np.floor() instead. For DataFrame, a DataFrame is returned; for Series, a Series is returned.

It is also possible to specify the axis argument in the NumPy function.

Compare the processing speeds of the map() and apply() methods of DataFrame with other dedicated methods and NumPy functions.

Consider a DataFrame with 100 rows and 100 columns.

Note that the following examples use the %%timeit magic command in Jupyter Notebook. They won't work if executed as a Python script.

The results for using the built-in abs() function with map(), compared to using the abs() method of DataFrame and the np.abs() function, are as follows. It can be observed that map() is slower.

The results for using the built-in sum() function with apply(), compared to using the sum() method of DataFrame and the np.sum() function, are as follows. It can be seen that apply() is slower. Although setting raw=True does speed it up, it is still significantly slower than sum() of DataFrame or np.sum().

The map() and apply() methods should be used primarily for complex operations that cannot be achieved with other methods or NumPy functions. If possible, it is better to use other methods or NumPy functions.